package com.zhao.fishingguideserver.service.impl;

import com.zhao.fishingguideserver.POJO.Order;
import com.zhao.fishingguideserver.POJO.Product;
import com.zhao.fishingguideserver.mapper.OrderMapper;
import com.zhao.fishingguideserver.mapper.ProductMapper;
import com.zhao.fishingguideserver.mapper.FavoriteMapper;
import com.zhao.fishingguideserver.mapper.CartMapper;
import com.zhao.fishingguideserver.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.UUID;

/**
 * 订单服务实现类
 */
@Service
public class OrderServiceImpl implements OrderService {
    
    @Autowired
    private OrderMapper orderMapper;
    
    @Autowired
    private ProductMapper productMapper;
    
    @Autowired
    private FavoriteMapper favoriteMapper;
    
    @Autowired
    private CartMapper cartMapper;
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public String createOrder(Order order) {
        try {
            // 验证商品是否存在
            Product product = productMapper.selectByPrimaryKey(order.getProductId().longValue());
            if (product == null) {
                return "商品不存在";
            }
            
            // 验证不能购买自己的商品
            if (product.getUserId().equals(order.getBuyerId())) {
                return "不能购买自己的商品";
            }
            
            // 设置卖家ID
            order.setSellerId(product.getUserId());
            
            // 设置购买价格
            order.setBuyPrice(product.getPrice());
            
            // 计算总金额
            BigDecimal totalAmount = product.getPrice().multiply(new BigDecimal(order.getQuantity()));
            order.setTotalAmount(totalAmount);
            
            // 生成订单号
            String orderCode = generateOrderCode();
            order.setCode(orderCode);
            
            // 检查商品状态（必须是在售状态）
            if (product.getStatus() != null && !"available".equals(product.getStatus())) {
                return "商品已下架或已售出";
            }
            
            // 设置默认状态
            order.setStatus("pending");
            
            // 插入订单
            int result = orderMapper.insert(order);
            
            // 订单创建成功后，必须立即更新商品状态为已预定（事务保证）
            if (result > 0) {
                // 1. 更新商品状态为已预定
                product.setStatus("reserved");
                int updateResult = productMapper.updateByPrimaryKeySelective(product);
                
                // 如果商品状态更新失败，回滚事务
                if (updateResult <= 0) {
                    throw new RuntimeException("商品状态更新失败，订单创建回滚");
                }
                
                System.out.println("订单创建成功：订单ID=" + order.getId() + "，商品ID=" + order.getProductId() + "，商品状态已更新为reserved");
                
                // 2. 删除该商品的所有收藏记录（所有用户的收藏）
                // 商品已被购买，不应再出现在任何人的收藏列表中
                try {
                    favoriteMapper.deleteByProductId(order.getProductId().longValue());
                } catch (Exception e) {
                    // 收藏删除失败不影响订单创建，仅记录日志
                    System.err.println("删除商品收藏记录失败: " + e.getMessage());
                }
                
                // 3. 删除该商品的所有购物车记录（所有用户的购物车）
                // 商品已被购买，不应再出现在任何人的购物车中
                try {
                    cartMapper.deleteByProductId(order.getProductId().longValue());
                } catch (Exception e) {
                    // 购物车删除失败不影响订单创建，仅记录日志
                    System.err.println("删除商品购物车记录失败: " + e.getMessage());
                }
                
                return "订单创建成功";
            }
            
            return "订单创建失败";
            
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("订单创建失败: " + e.getMessage());
        }
    }
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public String updateOrderStatus(Integer orderId, String status) {
        try {
            // 获取订单信息
            Order order = orderMapper.selectById(orderId);
            if (order == null) {
                return "订单不存在";
            }
            
            int result = orderMapper.updateStatus(orderId, status);
            
            // 根据订单状态更新商品状态
            if (result > 0) {
                Product product = productMapper.selectByPrimaryKey(order.getProductId().longValue());
                if (product != null) {
                    // 如果订单已送达，将商品状态更新为已售出
                    if ("delivered".equals(status)) {
                        product.setStatus("sold");
                        productMapper.updateByPrimaryKeySelective(product);
                    }
                    // 如果订单取消，将商品状态恢复为在售
                    else if ("cancelled".equals(status) && "reserved".equals(product.getStatus())) {
                        product.setStatus("available");
                        productMapper.updateByPrimaryKeySelective(product);
                    }
                }
            }
            
            return result > 0 ? "订单状态更新成功" : "订单状态更新失败";
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("订单状态更新失败: " + e.getMessage());
        }
    }
    
    @Override
    public String updateOrder(Order order) {
        try {
            int result = orderMapper.updateOrder(order);
            return result > 0 ? "订单更新成功" : "订单更新失败";
        } catch (Exception e) {
            e.printStackTrace();
            return "订单更新失败: " + e.getMessage();
        }
    }
    
    @Override
    public Order getOrderById(Integer orderId) {
        return orderMapper.selectById(orderId);
    }
    
    @Override
    public Order getOrderByCode(String code) {
        return orderMapper.selectByCode(code);
    }
    
    @Override
    public List<Order> getOrdersByBuyerId(Integer buyerId) {
        return orderMapper.selectByBuyerId(buyerId);
    }
    
    @Override
    public List<Order> getOrdersBySellerId(Integer sellerId) {
        return orderMapper.selectBySellerId(sellerId);
    }
    
    @Override
    public List<Order> getOrdersByStatus(String status) {
        return orderMapper.selectByStatus(status);
    }
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public String cancelOrder(Integer orderId, Integer userId) {
        try {
            // 验证订单是否存在
            Order order = orderMapper.selectById(orderId);
            if (order == null) {
                return "订单不存在";
            }
            
            // 验证权限（只有买家或卖家可以取消订单）
            if (!order.getBuyerId().equals(userId) && !order.getSellerId().equals(userId)) {
                return "无权限取消此订单";
            }
            
            // 验证订单状态
            if ("delivered".equals(order.getStatus()) || "cancelled".equals(order.getStatus())) {
                return "订单状态不允许取消";
            }
            
            int result = orderMapper.cancelOrder(orderId);
            
            // 订单取消成功后，必须将商品状态恢复为在售（事务保证）
            if (result > 0) {
                Product product = productMapper.selectByPrimaryKey(order.getProductId().longValue());
                if (product != null && "reserved".equals(product.getStatus())) {
                    product.setStatus("available");
                    int updateResult = productMapper.updateByPrimaryKeySelective(product);
                    
                    // 如果商品状态恢复失败，回滚事务
                    if (updateResult <= 0) {
                        throw new RuntimeException("商品状态恢复失败，订单取消回滚");
                    }
                }
                return "订单取消成功";
            }
            
            return "订单取消失败";
            
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("订单取消失败: " + e.getMessage());
        }
    }
    
    @Override
    public String deleteOrder(Integer orderId) {
        try {
            int result = orderMapper.deleteOrder(orderId);
            return result > 0 ? "订单删除成功" : "订单删除失败";
        } catch (Exception e) {
            e.printStackTrace();
            return "订单删除失败: " + e.getMessage();
        }
    }
    
    /**
     * 模拟支付功能
     * 将订单状态改为已支付，商品状态改为已售出
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public String payOrder(Integer orderId, Integer userId) {
        try {
            // 获取订单信息
            Order order = orderMapper.selectById(orderId);
            if (order == null) {
                return "订单不存在";
            }
            
            // 验证权限（只有买家可以支付）
            if (!order.getBuyerId().equals(userId)) {
                return "无权限支付此订单";
            }
            
            // 验证订单状态（必须是待支付状态）
            if (!"pending".equals(order.getStatus())) {
                return "订单状态不允许支付";
            }
            
            // 更新订单状态为已支付
            int result = orderMapper.updateStatus(orderId, "paid");
            
            if (result > 0) {
                // 更新商品状态为已售出
                Product product = productMapper.selectByPrimaryKey(order.getProductId().longValue());
                if (product != null) {
                    product.setStatus("sold");
                    int updateResult = productMapper.updateByPrimaryKeySelective(product);
                    
                    // 如果商品状态更新失败，回滚事务
                    if (updateResult <= 0) {
                        throw new RuntimeException("商品状态更新失败，支付回滚");
                    }
                    
                    System.out.println("支付成功：订单ID=" + orderId + "，商品ID=" + order.getProductId() + "，商品状态已更新为sold");
                }
                return "支付成功";
            }
            
            return "支付失败";
            
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("支付失败: " + e.getMessage());
        }
    }
    
    /**
     * 卖家发货功能
     * 将订单状态改为已发货
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public String shipOrder(Integer orderId, Integer userId) {
        try {
            // 获取订单信息
            Order order = orderMapper.selectById(orderId);
            if (order == null) {
                return "订单不存在";
            }
            
            // 验证权限（只有卖家可以发货）
            if (!order.getSellerId().equals(userId)) {
                return "无权限发货此订单";
            }
            
            // 验证订单状态（必须是已支付状态）
            if (!"paid".equals(order.getStatus())) {
                return "订单状态不允许发货";
            }
            
            // 更新订单状态为已发货
            int result = orderMapper.updateStatus(orderId, "shipped");
            
            return result > 0 ? "发货成功" : "发货失败";
            
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("发货失败: " + e.getMessage());
        }
    }
    
    /**
     * 买家确认收货功能
     * 将订单状态改为已送达，完成订单流程
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public String confirmReceipt(Integer orderId, Integer userId) {
        try {
            // 获取订单信息
            Order order = orderMapper.selectById(orderId);
            if (order == null) {
                return "订单不存在";
            }
            
            // 验证权限（只有买家可以确认收货）
            if (!order.getBuyerId().equals(userId)) {
                return "无权限确认收货此订单";
            }
            
            // 验证订单状态（必须是已发货状态）
            if (!"shipped".equals(order.getStatus())) {
                return "订单状态不允许确认收货";
            }
            
            // 更新订单状态为已送达
            int result = orderMapper.updateStatus(orderId, "delivered");
            
            return result > 0 ? "确认收货成功" : "确认收货失败";
            
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("确认收货失败: " + e.getMessage());
        }
    }
    
    /**
     * 生成订单号
     */
    private String generateOrderCode() {
        String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"));
        String uuid = UUID.randomUUID().toString().replace("-", "").substring(0, 8);
        return "ORD" + timestamp + uuid.toUpperCase();
    }
}